This PR implements the correct algorithm for computing the minimal number of operations to make an array constant in solution.cpp.

Problem

The task requires finding the minimal number of operations to transform any array into a constant array. The solution involves analyzing the adjacent differences and applying the correct mathematical approach.

Solution

The implemented algorithm works as follows:

1. Compute difference array: For input array a of size n, create difference array b of size n-1 where b[i] = a[i+1] - a[i]
2. Count operations: Count positive non-zero differences (increases) and negative non-zero differences (decreases) separately
3. Take maximum: The minimal operations required is max(positive_count, negative_count)

Mathematical Insight

To make an array constant, you must eliminate all differences between adjacent elements. You can either:

• Remove all increases (by applying decrease operations)
• Remove all decreases (by applying increase operations)

The optimal strategy is to choose whichever requires fewer operations, which corresponds to the maximum count of either increases or decreases.

Examples

// Input: [1, 3, 2, 4]
// Differences: [2, -1, 2] 
// Positive: 2, Negative: 1 → Answer: max(2,1) = 2

// Input: [5, 3, 1]  
// Differences: [-2, -2]
// Positive: 0, Negative: 2 → Answer: max(0,2) = 2

// Input: [5, 5, 5]
// Differences: [0, 0] 
// Positive: 0, Negative: 0 → Answer: max(0,0) = 0

Additional Changes

• Added .gitignore entries for CMake build directories to prevent build artifacts from being committed
• Cleaned up accidentally committed build files

The solution has been thoroughly tested with various edge cases including constant arrays, strictly increasing/decreasing sequences, and mixed patterns.

This pull request was created as a result of the following prompt from Copilot chat.

The current solution for computing the minimal number of operations to make an array constant is incorrect in some cases. We need to update the logic to count the number of positive and negative non-zero adjacent differences and take the maximum of these counts.

Specifically, after computing the difference array b of size n-1, the minimal operations is max(count of b[i]>0, count of b[i]<0).

Apply this change in solution.cpp. The second line of output for number of schemes remains zero for partial credit.

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.